CD Actual Thematic 25: Programming/pc_actual_25.iso/Delphi/Duck Report/_SETUP.1/dclDQuery.pas

Pascal/Delphi Source File | 1999-10-23 | 38.3 KB | 1,523 lines

Unit dclDQuery;
{$I DQuery.inc}

Interface
Uses
    Windows, Messages, SysUtils, Classes, Controls, Forms, Dialogs,
  DB, DBTables, DSGNINTF;
Const
  DQ_THIS_VERSION        = '010';
    DQ_PTHIS_VERSION        = '01.0';
    DQ_Display_VERSION    = '1.0c';

  TEXT_TAB                = Char(#09);
  MAX_ALIAS            = 50;
  MAX_PATH                = 255;
Type
    TDuckQuery        = Class;
  PRDQTable         = ^RDQTable;
    RDQTable         = Packed Record
     DataBase:        String[MAX_PATH];
     Table:            String[MAX_ALIAS];
     Alias:            String[MAX_ALIAS];
    End;
    TDQLinkType        = (tltEqual, tltGreater, tltLess, tltGreaterEqual,
                          tltLessEqual, tltNotEqual, tltLeftOuter,
                    tltRightOuter);
  PRDQLink         = ^RDQLink;
    RDQLink             = Packed Record
     TableLinkType:        TDQLinkType;
        MAlias:                String[MAX_ALIAS];
        MField:                String[MAX_ALIAS];
        DAlias:                String[MAX_ALIAS];
     DField:                String[MAX_ALIAS];
    End;
    PRDQField         = ^RDQField;
    RDQField         = Packed Record
     Data:            String[MAX_PATH];
        ColumnName:    String[MAX_ALIAS];
    End;

    TDQCriteriaAdd        = (caAnd, caor);
    TDQCriteriaType    = (scNone, scEqual, scNotEqual, scLess, scLessEqual,
                          scGreater, scGreaterEqual, scBetween, scBetweenEqual,
                    scNOTNULL, scNULL, scIN, scLike, scNotLike);

    PRDQCriterias         = ^RDQCriterias;
    RDQCriterias         = Packed Record
     Field:            String[MAX_ALIAS];
        CriteriaType:    TDQCriteriaType;
     Value1:            String[MAX_PATH];
     Value2:            String[MAX_PATH];
     AddType:            TDQCriteriaAdd;
    End;

  PRDQGroup         = ^RDQGroup;
    RDQGroup         = Packed Record
      Field:        String[MAX_ALIAS];
    End;

  TDQSortType    = (gsAscending, gsDecending); { ASC, DESC }
  PRDQSort            = ^RDQSort;
    RDQSort             = Packed Record
      SortType:    TDQSortType;
        Field:        String[MAX_ALIAS];
    End;

  PRDQTableInfo    = ^RDQTableInfo;
    RDQTableInfo     = Packed Record
      Alias:        String[MAX_ALIAS];
        Table:        TTable;
     FieldName:    TStrings;
    End;

  TDREventFind    = Procedure (Sender: TObject;
                              St: String; Var iResult: Integer) of Object;
  TDREventFindPt    = Procedure (Sender: TObject;
                              St: String; Var pt: Pointer) of Object;
  { ---------- TDQList ---------- }
    TDQList        = Class (TPersistent)
  Private
  Protected
      FOwner:        TDuckQuery;
     FSize:        Integer;
     List:            TList;
     FOnFind:        TDREventFind;
     FOnFindPt:    TDREventFindPt;

     Function        GetCount: Integer;
     Function        GetItems (Index: Integer): Pointer; Virtual;
     Procedure    SetItems (Index: Integer; Item: Pointer); Virtual;
     Procedure    ReadData (Stream: TStream);
        Procedure    WriteData (Stream: TStream);
     Procedure    DefineProperties (Filer: TFiler); Override;
    Public
      Constructor    Create (AOwner: TDuckQuery; ASize: Integer); Virtual;
        Destructor    Destroy; Override;
     Procedure    Clear;
     Procedure    Assign (Source: TPersistent); Override;
     Procedure    Move(CurIndex, NewIndex: Integer);
     Function        Add(Item: Pointer): Integer;
     Procedure    Insert (Index: Integer; Item: Pointer);
     Procedure    Delete (Index: Integer);
     Function        FindAsString (St: String): Integer;
     Function        FindAsStringPt (St: String): Pointer;
     Property        Items[Index: Integer]:    Pointer Read GetItems
                                         Write SetItems; default;
    Published
      Property        Count:    Integer Read GetCount;
     Property        Size:        Integer Read FSize;
     Property        OnFind:        TDREventFind Read FOnFind Write FOnFind;
     Property        OnFindPt:    TDREventFindPt Read FOnFindPt Write FOnFindPt;
    End;
    { ---------- TDuckQuery ---------- }
    TDuckQuery = Class (TQuery)
    Private
  Protected
      FVersion:        Integer;
     FTables:            TDQList;
     FTableLink:        TDQList;
     FSelectFields:    TDQList;
     FCriterias:        TDQList;
     FGroups:            TDQList;
     FSorts:            TDQList;
     FTableInfo:        TDQList;
     FDuplicate:        Boolean;

     Procedure        SetTables (Const Value: TDQList);
        Procedure        SetTableLink (Const Value: TDQList);
        Procedure        SetSelectFields (Const Value: TDQList);
     Procedure        SetCriterias (Const Value: TDQList);
     Procedure        SetGroups (Const Value: TDQList);
     Procedure        SetSorts (Const Value: TDQList);

     Procedure        FindTable (Sender: TObject; St: String; Var iResult: Integer);
     Procedure        FindTabbleInfo (Sender: TObject; St: String; Var iResult: Integer);
     Procedure        FindField (Sender: TObject; St: String; Var iResult: Integer);
     Procedure        FindGroup (Sender: TObject; St: String; Var iResult: Integer);
     Procedure        FindSort (Sender: TObject; St: String; Var iResult: Integer);
     Procedure        FindCriterias (Sender: TObject; St: String; Var iResult: Integer);

     Procedure        FindTablePt (Sender: TObject; St: String; Var pt: Pointer);
     Procedure        FindTabbleInfoPt (Sender: TObject; St: String; Var pt: Pointer);
     Procedure        FindFieldPt (Sender: TObject; St: String; Var pt: Pointer);

    Public
      Constructor    Create (AOwner: TComponent); Override;
        Destructor    Destroy; Override;
     Procedure    Assign (Source: TPersistent); Override;
     Procedure    GetSQL (SQL: TStrings);
     Procedure    DoSQL;
     Function        SaveFile (StFile: String): Boolean;
     Function        OpenFile (StFile: String): Boolean;
     Function        SaveTextFile (StFile: String): Boolean;
     Procedure    SaveToStream (Stream: TStream);
     Function        LoadFromStream (Stream: TStream): Boolean;

     Function        OpenFileDlg: Boolean;
     Function        SaveFileDlg: Boolean;
     Function        SaveTxtFileDlg: Boolean;
     Procedure    ViewSQL;

     Procedure    Clear;
     Procedure    Editor (Index: Integer);

     Property        TableInfo:    TDQList Read FTableInfo;
    Published
        Property        DQTables:        TDQList Read FTables Write SetTables;
        Property        DQTableLinks:    TDQList Read FTableLink Write SetTableLink;
        Property        DQFields:        TDQList Read FSelectFields Write SetSelectFields;
     Property        DQCriterias:    TDQList Read FCriterias Write SetCriterias;
     Property        DQGroups:        TDQList Read FGroups Write SetGroups;
     Property        DQSorts:            TDQList Read FSorts Write SetSorts;
     Property        Duplicate:        Boolean Read FDuplicate Write FDuplicate Default TRUE;
    End;
  { ---------- TDQListProperty ---------- }
  TDQListProperty = Class(TClassProperty)
    Public
      Procedure    EditItem (Index: Integer);
        Function        GetAttributes: TPropertyAttributes; Override;
    End;
  { ---------- TDQTablesProperty ---------- }
  TDQTablesProperty = Class(TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;
  { ---------- TDQTableLinksProperty ---------- }
  TDQTableLinksProperty = Class(TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;
  { ---------- TDQFieldsProperty ---------- }
  TDQFieldsProperty = Class(TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;
  { ---------- TDQCriteriasProperty ---------- }
  TDQCriteriasProperty = Class(TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;
  { ---------- TDQGroupsProperty ---------- }
  TDQGroupsProperty = Class(TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;
  { ---------- TDQSortsProperty ---------- }
  TDQSortsProperty = Class (TDQListProperty)
    Public
        Procedure    Edit; Override;
    End;

  { ---------- TDQListDefault ---------- }
  TDQListDefault = class(TDefaultEditor)
    Protected
        Procedure    EditProperty(PropertyEditor: TPropertyEditor;
                        var Continue, FreeEditor: Boolean); Override;
  Public
        Procedure    ExecuteVerb(Index: Integer); Override;
        Function        GetVerb(Index: Integer): String; Override;
        Function        GetVerbCount: Integer; Override;
    End;

Procedure    Register;
Function    DQCutCharInString (St: String; StD: String): String;
Implementation
Uses QueryEditor, DQViewText, DQViewData;
{$R dclDQuery.Dcr}
Procedure    Register;
Begin
    RegisterComponents ('DuckTech', [TDuckQuery]);
  RegisterComponentEditor (TDuckQuery, TDQListDefault);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQTables',
        TDQTablesProperty);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQTableLinks',
        TDQTableLinksProperty);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQFields',
        TDQFieldsProperty);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQCriterias',
        TDQCriteriasProperty);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQGroups',
        TDQGroupsProperty);
  RegisterPropertyEditor (TypeInfo(TDQList), TDuckQuery, 'DQSorts',
        TDQSortsProperty);
End;
Function    DQCutCharInString (St: String; StD: String): String;
Var
    i:            Integer;
  iLength:    Integer;
  iFind:    Integer;
Begin
    Result    := St;
  i            := 1;
  iLength    := Length (Result);
  While i <= iLength Do
  Begin
      iFind    := Pos (Result[i], StD);
      if iFind > 0 Then
     Begin
         Delete (Result, i, 1);
        Dec (iLength);
      End
     Else
         Inc (i);
  End;
End;
Function    DQGetVersion (St: String): Integer;
Begin
    St            := DQCutCharInString (St, '.');
  Result    := StrToInt (St);
End;
{ ---------- TDQListProperty ---------- }
Procedure TDQListProperty.EditItem (Index: Integer);
Var
    DuckQuery:    TDuckQuery;
Begin
  if not (GetComponent(0) is TDuckQuery) Then Exit;
    DuckQuery        := TDuckQuery (GetComponent(0));
  DuckQuery.Editor (Index);
End;
Function TDQListProperty.GetAttributes : TPropertyAttributes;
Begin
  Result := [paDialog];
End;
{ ---------- TDQTablesProperty ---------- }
Procedure TDQTablesProperty.Edit;
Begin
    EditItem (0);
End;
{ ---------- TDQTableLinksProperty ---------- }
Procedure TDQTableLinksProperty.Edit;
Begin
    EditItem (1);
End;
{ ---------- TDQFieldsProperty ---------- }
Procedure TDQFieldsProperty.Edit;
Begin
    EditItem (2);
End;
{ ---------- TDQCriteriasProperty ---------- }
Procedure TDQCriteriasProperty.Edit;
Begin
    EditItem (3);
End;
{ ---------- TDQGroupsProperty ---------- }
Procedure TDQGroupsProperty.Edit;
Begin
    EditItem (4);
End;
{ ---------- TDQSortsProperty ---------- }
Procedure TDQSortsProperty.Edit;
Begin
    EditItem (5);
End;
{ ---------- TDQListDefault ---------- }
Procedure TDQListDefault.EditProperty(PropertyEditor: TPropertyEditor;
  var Continue, FreeEditor: Boolean);
var
  PropName: string;
Begin
    PropName := PropertyEditor.GetName;
    if (CompareText(PropName, 'DQTABLES') = 0) then
  begin
    PropertyEditor.Edit;
    Continue := False;
  end;
End;
Function TDQListDefault.GetVerbCount: Integer;
Begin
  Result := 7;
End;

function TDQListDefault.GetVerb(Index: Integer): string;
Begin
    Case Index of
      0:    Result    := 'Duck Query 1.0';
     1:    Result    := 'Duck &Query Editor';
     2:    Result    := '&View SQL';
     3:    Result    := '&Open';
     4:    Result    := '&Save';
        5:    Result    := 'Save To &TextFile';
     6:    Result    := '&Clear All';
  Else
      Result := '';
  End
End;

Procedure TDQListDefault.ExecuteVerb(Index: Integer);
Var
    DuckQuery:    TDuckQuery;
Begin
    if Index = 0 Then
      Exit
  Else
    if Index = 1 Then
      Edit
  Else
  Begin
      if not (Component is TDuckQuery) Then Exit;
        DuckQuery        := TDuckQuery (Component);
      Case Index of
         2:    // View SQL
            DuckQuery.ViewSQL;
            3:    // Open
            DuckQuery.OpenFileDlg;
         4:    // Save
            DuckQuery.SaveFileDlg;
            5:    // Save To &TextFile
            DuckQuery.SaveTxtFileDlg;
         6:    // Clear All
        Begin
            DuckQuery.Clear;
            End;
      End;
  End;
End;
{ ---------- TDQList ---------- }
Constructor TDQList.Create (AOwner: TDuckQuery; ASize: Integer);
Begin
    inherited Create;
  FOwner    := AOwner;
  FSize        := ASize;
  List        := TList.Create;
End;
Destructor TDQList.Destroy;
Begin
    Clear;
  List.Free;
    inherited Destroy;
End;
Function TDQList.GetCount: Integer;
Begin
    Result    := List.Count;
End;
Procedure TDQList.Clear;
Var
    i:        Integer;
  pt:    Pointer;
Begin
    For i := 0 To List.Count - 1 Do
  Begin
      pt    := List[i];
     FreeMem (pt, Size);
  End;
  List.Clear;
End;
Procedure TDQList.Assign (Source: TPersistent);
Var
    i:            Integer;
  pt:        Pointer;
  S:            TDQList;
Begin
    if not (Source is TDQList) Then Exit;
//  inherited Assign (Source);
  S    := TDQList (Source);
  Clear;
  FSize    := S.Size;
    For i := 0 To S.List.Count - 1 Do
    Begin
        pt    := S.List[i];
     Add (pt);
    End;
End;
Procedure TDQList.Move (CurIndex, NewIndex: Integer);
Begin
    List.Move(CurIndex, NewIndex);
End;
Function TDQList.GetItems (Index: Integer): Pointer;
Begin
    Result    := nil;
    if (Index < 0) or (Index >= List.Count) Then Exit;
    Result    := List[Index];
End;
Procedure TDQList.SetItems (Index: Integer; Item: Pointer);
Var
    pt:    Pointer;
Begin
    if (Index < 0) or (Index >= List.Count) Then Exit;
    pt    := List[Index];
    System.Move (Item^, pt^, Size);
End;
Function TDQList.Add(Item: Pointer): Integer;
Var
    pt:    Pointer;
Begin
    GetMem (pt, Size);
  System.Move (Item^, pt^, Size);
  Result    := List.Add (pt);
End;
Procedure TDQList.Insert (Index: Integer; Item: Pointer);
Var
    pt:    Pointer;
Begin
    GetMem (pt, Size);
  System.Move (Item^, pt^, Size);
    List.Insert (Index, pt);
End;
Procedure TDQList.Delete (Index: Integer);
Var
    pt:    Pointer;
Begin
    if (Index < 0) or (Index >= List.Count) Then Exit;
    pt    := List[Index];
    FreeMem (pt, Size);
    List.Delete (Index);
End;
{
Procedure TDQList.ReadData (Reader: TReader);
Var
    pt:        Pointer;
  i:            Integer;
  iCount:    Integer;
Begin
  Reader.ReadListBegin;
  Writer.WriteInteger (FSize);
  Writer.WriteInteger (Count);
  GetMem (pt, Size);
  Try
        Clear;
        While not Reader.EndOfList Do
        Begin
            Reader.Read (pt^, Size);
            Add (pt);
        End;
  Finally
        FreeMem (pt, Size);
    End;
  Reader.ReadListEnd;
End;
}
Procedure TDQList.ReadData (Stream: TStream);
Var
    pt:        Pointer;
  i:            Integer;
  iCount:    Integer;
Begin
    Clear;
  Stream.ReadBuffer (FSize, Sizeof (FSize));
  Stream.ReadBuffer (iCount, Sizeof (iCount));
  GetMem (pt, Size);
  Try
        For i := 0 To iCount - 1 Do
     Begin
         Stream.ReadBuffer (pt^, Size);
            Add (pt);
        End;
  Finally
        FreeMem (pt, Size);
    End;
End;
Procedure TDQList.WriteData (Stream: TStream);
Var
    i:        Integer;
Begin
    Stream.WriteBuffer (FSize, Sizeof (FSize));
  i    := Count;
  Stream.WriteBuffer (i, Sizeof (i));
    for i := 0 to List.Count - 1 Do
        Stream.WriteBuffer (List[i]^, Size);
End;
Procedure TDQList.DefineProperties (Filer: TFiler);
    Function DoWrite: Boolean;
  Begin
        if Filer.Ancestor <> nil Then
        Begin
            Result := True;
            if Filer.Ancestor is TDQList then
                Result := TRUE;
        End
        Else
            Result := Count > 0;;
    End;
Begin
    Filer.DefineBinaryProperty('Data', ReadData, WriteData, DoWrite);
End;
Function TDQList.FindAsString (St: String): Integer;
Begin
    Result    := -1;
  if Assigned (FOnFind) Then
      FOnFind (Self, St, Result);
End;
Function TDQList.FindAsStringPt (St: String): Pointer;
Begin
    Result    := nil;
  if Assigned (FOnFindPt) Then
      FOnFindPt (Self, St, Result);
End;
{ ---------- TDuckQuery ---------- }
Constructor TDuckQuery.Create (AOwner: TComponent);
Begin
    inherited Create (AOwner);
  FVersion            := StrToInt (DQ_THIS_VERSION);
  FDuplicate        := TRUE;
    FTables            := TDQList.Create (Self, Sizeof (RDQTable));
    FTableLink        := TDQList.Create (Self, Sizeof (RDQLink));
    FSelectFields    := TDQList.Create (Self, Sizeof (RDQField));

  FCriterias    := TDQList.Create (Self, Sizeof (RDQCriterias));
    FGroups        := TDQList.Create (Self, Sizeof (RDQGroup));
    FSorts        := TDQList.Create (Self, Sizeof (RDQSort));
  FTableInfo    := TDQList.Create (Self, Sizeof (RDQTableInfo));

  FTables.OnFind                := FindTable;
    FTableInfo.OnFind            := FindTabbleInfo;
  FSelectFields.OnFind        := FindField;
  FGroups.OnFind                := FindGroup;
    FSorts.OnFind                := FindSort;
    FCriterias.OnFind            := FindCriterias;

  FTables.OnFindPt            := FindTablePt;
    FTableInfo.OnFindPt        := FindTabbleInfoPt;
  FSelectFields.OnFindPt    := FindFieldPt;
End;
Destructor TDuckQuery.Destroy;
Begin
    Clear;
    FTables.Free;
    FTableLink.Free;
    FSelectFields.Free;
  FCriterias.Free;
    FGroups.Free;
    FSorts.Free;
  FTableInfo.Free;
    inherited Destroy;
End;
Procedure TDuckQuery.Assign (Source: TPersistent);
Var
    S:    TDuckQuery;
Begin
    if not (Source is TDuckQuery) Then Exit;
//  inherited Assign (Source);
    S                    := TDuckQuery (Source);
  Duplicate        := S.Duplicate;
    DQTables            := S.DQTables;
    DQTableLinks    := S.DQTableLinks;
    DQFields            := S.DQFields;
  DQCriterias        := S.DQCriterias;
    DQGroups            := S.DQGroups;
    DQSorts            := S.DQSorts;
End;
Procedure TDuckQuery.Clear;
Begin
    DQTables.Clear;
    DQTableLinks.Clear;
    DQFields.Clear;
  DQCriterias.Clear;
    DQGroups.Clear;
    DQSorts.Clear;
End;
Procedure TDuckQuery.SetTables (Const Value: TDQList);
Begin
    FTables.Assign (Value);
End;
Procedure TDuckQuery.SetTableLink (Const Value: TDQList);
Begin
    FTableLink.Assign (Value);
End;
Procedure TDuckQuery.SetSelectFields (Const Value: TDQList);
Begin
    FSelectFields.Assign (Value);
End;
Procedure TDuckQuery.SetCriterias (Const Value: TDQList);
Begin
    FCriterias.Assign (Value);
End;
Procedure TDuckQuery.SetGroups (Const Value: TDQList);
Begin
    FGroups.Assign (Value);
End;
Procedure TDuckQuery.SetSorts (Const Value: TDQList);
Begin
    FSorts.Assign (Value);
End;
Procedure TDuckQuery.FindTable (Sender: TObject; St: String; Var iResult: Integer);
Var
    TablePtr:    PRDQTable;
  i:                Integer;
Begin
    iResult    := -1;
  For i := 0 To FTables.Count - 1 Do
  Begin
      TablePtr    := FTables[i];
     if TablePtr.Alias = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;
Procedure TDuckQuery.FindTabbleInfo (Sender: TObject; St: String; Var iResult: Integer);
Var
    TableInfoPtr:    PRDQTableInfo;
  i:                Integer;
Begin
    iResult    := -1;
  For i := 0 To FTableInfo.Count - 1 Do
  Begin
      TableInfoPtr    := FTableInfo[i];
     if TableInfoPtr.Alias = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;
Procedure TDuckQuery.FindField (Sender: TObject; St: String; Var iResult: Integer);
Var
    FieldPtr:    PRDQField;
  i:                Integer;
Begin
    iResult    := -1;
  For i := 0 To FSelectFields.Count - 1 Do
  Begin
      FieldPtr    := FSelectFields[i];
     if FieldPtr.ColumnName = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;
Procedure TDuckQuery.FindGroup (Sender: TObject; St: String; Var iResult: Integer);
Var
    GroupPtr:    PRDQGroup;
  i:                Integer;
Begin
    iResult    := -1;
  For i := 0 To FGroups.Count - 1 Do
  Begin
      GroupPtr    := FGroups[i];
     if GroupPtr.Field = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;
Procedure TDuckQuery.FindSort (Sender: TObject; St: String; Var iResult: Integer);
Var
    SortPtr:        PRDQSort;
  i:                Integer;
Begin
    iResult    := -1;
  For i := 0 To FSorts.Count - 1 Do
  Begin
      SortPtr    := FSorts[i];
     if SortPtr.Field = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;
Procedure TDuckQuery.FindCriterias (Sender: TObject; St: String; Var iResult: Integer);
Var
    CriteriasPtr:    PRDQCriterias;
  i:                    Integer;
Begin
    iResult    := -1;
  For i := 0 To FCriterias.Count - 1 Do
  Begin
        CriteriasPtr    := FCriterias[i];
     if CriteriasPtr.Field = St Then
     Begin
         iResult    := i;
        Break;
     End;
  End;
End;

Procedure TDuckQuery.FindTablePt (Sender: TObject; St: String; Var pt: Pointer);
Var
    i:        Integer;
Begin
    pt        := nil;
    FindTable (Sender, St, i);
  if i >= 0 Then
      pt    := FTables[i];
End;
Procedure TDuckQuery.FindTabbleInfoPt (Sender: TObject; St: String; Var pt: Pointer);
Var
    i:        Integer;
Begin
    pt   := nil;
    FindTabbleInfo (Sender, St, i);
  if i >= 0 Then
      pt    := FTableInfo[i];
End;
Procedure TDuckQuery.FindFieldPt (Sender: TObject; St: String; Var pt: Pointer);
Var
    i:        Integer;
Begin
    pt   := nil;
    FindField (Sender, St, i);
  if i >= 0 Then
      pt    := DQFields[i];
End;
Procedure TDuckQuery.DoSQL;
Begin
    GetSQL (SQL);
End;
Procedure TDuckQuery.GetSQL (SQL: TStrings);
Label
    ExieSQL;
Var
    i:                    Integer;
  iTemp:            Integer;
  bOuter:            Boolean;
  bWhere:            Boolean;
  bSameReport:    Boolean;

  TablePtr:        PRDQTable;
  TableOuterPtr:    PRDQTable;
    LinkPtr:            PRDQLink;
  LinkOPtr:        PRDQLink;
  FieldPtr:        PRDQField;
  GroupPtr:        PRDQGroup;
  SortPtr:            PRDQSort;
  CriteriasPtr:    PRDQCriterias;
  TableInfoPtr:    PRDQTableInfo;

  StSQL:            String;

  {$IFDEF VERIFY_MSACCESS}
  bAccess:            Boolean;
  StDB:                String;
    {$ENDIF}

  Function        FindOuter (bTarget: Boolean): Boolean;
  Var
      j:                    Integer;
     St:                String;
  Begin
      Result    := FALSE;
     For j := 0 To FTableLink.Count - 1 Do
      Begin
          LinkOPtr    := FTableLink[j];
        Case LinkOPtr.TableLinkType of
           tltLeftOuter,
           tltRightOuter:
           Begin
                    if bTarget Then    St    := LinkOPtr.DAlias
              Else                    St    := LinkOPtr.MAlias;
               if St = TablePtr.Alias Then
              Begin
                  Result    := TRUE;
                 Break;
              End;
           End;
        End;
     End;
     if not Result Then
         LinkOPtr    := nil;
  End;
  Procedure    PutTable (ATablePtr: PRDQTable);
  Begin
      if ATablePtr.DataBase = '' Then
     Begin
{         bSameReport    := TRUE;
        StSQL    := '''';
            StSQL    := StSQL + FDirectory;
        StSQL    := StSQL + '\';
        StSQL    := StSQL + DRTable.Table;
        StSQL    := StSQL + '''';}
     End
     Else
            if ATablePtr.DataBase[Length (ATablePtr.DataBase)] = '\' Then
         Begin
             StSQL    := StSQL + '''';
           StSQL    := StSQL + ATablePtr.DataBase;
             StSQL    := StSQL + ATablePtr.Table;
           StSQL    := StSQL + '''';
         End
         Else
         Begin
           {$IFDEF VERIFY_MSACCESS}
           if bAccess Then
              StSQL    := StSQL + '[' + ATablePtr.Table + ']'
           Else
           Begin
           {$ENDIF}
               StSQL    := StSQL + ''':';
               StSQL    := StSQL + ATablePtr.DataBase;
                 StSQL    := StSQL + ':';
               StSQL    := StSQL + ATablePtr.Table;
               StSQL    := StSQL + '''';
           {$IFDEF VERIFY_MSACCESS}
           End;
           {$ENDIF}
         End;
        StSQL    := StSQL + ' ';
     StSQL    := StSQL + ATablePtr.Alias;
  End;

  {$IFDEF VERIFY_MSACCESS}
  Procedure    StrCatStrNotString (St: String);
  Var
      iPos:    Integer;
  Begin
      iPos    := Pos ('''', St);
     if iPos <= 0 Then Exit;
     St[iPos]    := '[';

        iPos    := Pos ('''', St);
     if iPos <= 0 Then Exit;
     St[iPos]    := ']';
     StSQL    := StSQL + St;
  End;
  Function    TestAccess: String;
  Var
      i:                    Integer;
     TempSession:    TSession;
     St:                String;
  Begin
      Result    := '';
     TempSession    := DBSession;
     if TempSession = nil Then
         TempSession    := Session;
     For i := 0 To FTables.Count - 1 Do
      Begin
          TablePtr    := FTables[i];
            if TablePtr = nil Then Continue;
        St    := TempSession.GetAliasDriverName (TablePtr.DataBase);
        if St = 'MSACCESS' Then
        Begin
           Result    := TablePtr.DataBase;
           Exit;
        End;
        End;
  End;
  {$ENDIF}
Begin
    {$IFDEF VERIFY_MSACCESS}
    bAccess    := FALSE;
  StDB        := '';
  {$ENDIF}

  SQL.Clear;
  SQL.BeginUpdate;
  Try
    StSQL    := 'SELECT';
  if FDuplicate Then
        StSQL    := StSQL + ' DISTINCT';
  {$IFDEF VERIFY_MSACCESS}
    StDB        := TestAccess;
  if StDB <> '' Then
      bAccess    := TRUE;
  {$ENDIF}
  For i := 0 To FSelectFields.Count - 1 Do
  Begin
      if i <> 0 Then
         StSQL    := StSQL + ',';
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
     FieldPtr    := FSelectFields[i];
     if FieldPtr = nil Then Continue;

     {$IFDEF VERIFY_MSACCESS}
     if bAccess Then
         StrCatStrNotString (FieldPtr.Data)
     Else
     {$ENDIF}
         StSQL    := StSQL + FieldPtr.Data;
        if FieldPtr.ColumnName <> '' Then
        Begin
            StSQL    := StSQL + ' AS ';
        StSQL    := StSQL + FieldPtr.ColumnName;
     End;
  End;
//QueryLB:
    if FTables.Count <= 0 Then Goto ExieSQL;
  bOuter    := FALSE;
  bWhere    := FALSE;

    For i := 0 To FTables.Count - 1 Do
  Begin
      TablePtr    := FTables[i];
        if TablePtr = nil Then Continue;
      if FindOuter (TRUE) Then Continue;

      if i = 0 Then
     Begin
         SQL.Add (StSQL);
         StSQL    := '';
            StSQL    := StSQL + 'FROM';
     End
     Else
         StSQL    := StSQL + ',';
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
        PutTable (TablePtr);
     bOuter            := FindOuter (FALSE);
     TableOuterPtr    := nil;
     if bOuter Then
            TableOuterPtr    := FTables.FindAsStringPt (LinkOPtr.DAlias);
     if TableOuterPtr = nil Then Continue;
     { Have Outer Join }

     Case LinkOPtr.TableLinkType of
         tltLeftOuter:    StSQL    := StSQL + ' LEFT OUTER JOIN ';
        tltRightOuter:    StSQL    := StSQL + ' RIGHT OUTER JOIN ';
     End;
     PutTable (TableOuterPtr);

     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
     StSQL    := StSQL + 'ON (';
     StSQL    := StSQL + LinkOPtr.MAlias;
     StSQL    := StSQL + '.';
     {$IFDEF VERIFY_MSACCESS}
     if bAccess Then
        StSQL    := StSQL + '[' + LinkOPtr.MField + ']'
     Else
     {$ENDIF}
         StSQL    := StSQL + '''' + LinkOPtr.MField + '''';

     StSQL    := StSQL + ' = ';
     StSQL    := StSQL + LinkOPtr.DAlias;
        StSQL    := StSQL + '.';
     {$IFDEF VERIFY_MSACCESS}
     if bAccess Then
        StSQL    := StSQL + '[' + LinkOPtr.DField + ']'
     Else
     {$ENDIF}
         StSQL    := StSQL + '''' + LinkOPtr.DField + '''';
     StSQL    := StSQL + ')';
  End;
  For i := 0 To DQTableLinks.Count - 1 Do
  Begin
      LinkPtr    := DQTableLinks[i];
        if LinkPtr = nil Then Continue;
      Case LinkPtr.TableLinkType of
         tltLeftOuter,
         tltRightOuter:    Continue;
     End;

      if i = 0 Then
     Begin
         SQL.Add (StSQL);
         StSQL    := '';
            StSQL    := StSQL + 'WHERE';
        bWhere    := TRUE;
     End
     Else
         StSQL    := StSQL + ' AND ';
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
     LinkPtr    := DQTableLinks[i];
        if LinkPtr = nil Then Continue;

            StSQL    := StSQL + '(';
        StSQL    := StSQL + LinkPtr.MAlias;
        StSQL    := StSQL + '.';
        {$IFDEF VERIFY_MSACCESS}
        if bAccess Then
           StSQL    := StSQL + '[' + LinkPtr.MField + ']'
        Else
        {$ENDIF}
                StSQL    := StSQL + '''' + LinkPtr.MField + '''';
            Case LinkPtr.TableLinkType of
                tltEqual:            {=}        StSQL    := StSQL + ' = ';
           tltGreater:            {>}        StSQL    := StSQL + ' > ';
           tltLess:                {<}        StSQL    := StSQL + ' > ';
           tltGreaterEqual:    {>=}        StSQL    := StSQL + ' >= ';
              tltLessEqual:        {<=}        StSQL    := StSQL + ' <= ';
           tltNotEqual:        {<>}        StSQL    := StSQL + ' <> ';
        Else
            StSQL    := StSQL + ' = ';
            End;
            StSQL    := StSQL + LinkPtr.DAlias;
        StSQL    := StSQL + '.';

        {$IFDEF VERIFY_MSACCESS}
        if bAccess Then
           StSQL    := StSQL + '[' + LinkPtr.DField + ']'
        Else
        {$ENDIF}
                StSQL    := StSQL + '''' + LinkPtr.DField + '''';

        StSQL    := StSQL + ')';
    End;

  For i := 0 To DQCriterias.Count - 1 Do
  Begin
      CriteriasPtr    := DQCriterias[i];
      if (i = 0) and (bWhere = FALSE) Then
     Begin
         SQL.Add (StSQL);
         StSQL    := '';
         StSQL    := StSQL + 'WHERE';
     End
     Else
     Begin
         if i = 0 Then
                StSQL    := StSQL + ' AND'
        Else
        Begin
            if CriteriasPtr.AddType = caAnd Then
                    StSQL    := StSQL + ' AND'
           Else
               StSQL    := StSQL + ' OR';
        End;
     End;
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
     StSQL    := StSQL + '(';
     StSQL    := StSQL + CriteriasPtr.Field;
     Case CriteriasPtr.CriteriaType of
         scEqual:                StSQL    := StSQL + ' = ';
        scNotEqual:            StSQL    := StSQL + ' <> ';
         scLess:                StSQL    := StSQL + ' < ';
         scLessEqual:        StSQL    := StSQL + ' <= ';
         scGreater:            StSQL    := StSQL + ' > ';
            scGreaterEqual:    StSQL    := StSQL + ' >= ';
         scBetween:            StSQL    := StSQL + ' > ';
         scBetweenEqual:    StSQL    := StSQL + ' >= ';
        scNULL:
            Begin
               StSQL    := StSQL + ' IS NULL)';
              Continue;
           End;
        scNOTNULL:
            Begin
               StSQL    := StSQL + ' IS NOT NULL)';
              Continue;
           End;
        scIN:                StSQL    := StSQL + ' IN ( ';
        scLike:            StSQL    := StSQL + ' LIKE ';
        scNotLike:        StSQL    := StSQL + ' NOT LIKE ';
     End;
     StSQL    := StSQL + CriteriasPtr.Value1;
     StSQL    := StSQL + ')';
     Case CriteriasPtr.CriteriaType of
            scEqual,
        scNotEqual,
         scLess,
         scLessEqual,
         scGreater,
            scGreaterEqual,
        scNOTNULL,
        scLike,
        scNotLike:        Continue;
            scIN:
            Begin
               StSQL    := StSQL + ')';
              Continue;
           End;
        End;
     StSQL    := StSQL + ' And (';
     StSQL    := StSQL + CriteriasPtr.Field;
     Case CriteriasPtr.CriteriaType of
         scBetween:            StSQL    := StSQL + ' < ';
         scBetweenEqual:    StSQL    := StSQL + ' <= ';
        End;
        StSQL    := StSQL + CriteriasPtr.Value2;
     StSQL    := StSQL + ')';
  End;

  For i := 0 To FGroups.Count - 1 Do
  Begin
      GroupPtr    := FGroups[i];
     if GroupPtr = nil Then Continue;
      if i = 0 Then
     Begin
         SQL.Add (StSQL);
         StSQL    := '';
            StSQL    := StSQL + 'GROUP BY';
     End
     Else
         StSQL    := StSQL + ',';
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;

     {$IFDEF VERIFY_MSACCESS}
     if bAccess Then
     Begin
         iTemp        := FSelectFields.FindAsString (GroupPtr.Field);
        if iTemp >= 0 Then
        Begin
             FieldPtr    := FSelectFields[iTemp];
            if FieldPtr = nil Then
                StSQL    := StSQL + GroupPtr.Field
            Else
                StrCatStrNotString (FieldPtr.Data);
        End
        Else
            StSQL    := StSQL + GroupPtr.Field;
     End
     Else
     {$ENDIF}
         StSQL    := StSQL + GroupPtr.Field;
  End;
  For i := 0 To FSorts.Count - 1 Do
  Begin
      SortPtr    := FSorts[i];
     if SortPtr = nil Then Continue;
      if i = 0 Then
     Begin
         SQL.Add (StSQL);
         StSQL    := '';
            StSQL    := StSQL + 'ORDER BY';
     End
     Else
         StSQL    := StSQL + ',';
     SQL.Add (StSQL);
     StSQL    := '';
     StSQL    := StSQL + TEXT_TAB;
     {$IFDEF VERIFY_MSACCESS}
     if bAccess Then
     Begin
         iTemp        := FSelectFields.FindAsString (SortPtr.Field);
        if iTemp >= 0 Then
        Begin
             FieldPtr    := FSelectFields[iTemp];
            if FieldPtr = nil Then
                StSQL    := StSQL + SortPtr.Field
            Else
                StrCatStrNotString (FieldPtr.Data);
        End
        Else
            StSQL    := StSQL + SortPtr.Field;
     End
     Else
     {$ENDIF}
         StSQL    := StSQL + SortPtr.Field;
        Case SortPtr.SortType of
         gsAscending:    StSQL    := StSQL + ' ASC';
        gsDecending:    StSQL    := StSQL + ' DESC';
     End;
  End;
  if StSQL <> '' Then
      SQL.Add (StSQL);
ExieSQL:
  Finally
      SQL.EndUpdate;
     {$IFDEF VERIFY_MSACCESS}
      if bAccess Then
         Self.DatabaseName    := StDB;
      {$ENDIF}
  End;
End;
Function TDuckQuery.SaveFile (StFile: String): Boolean;
Var
  Stream:    THandleStream;
  iFile:    Integer;
Begin
    Result    := FALSE;
    iFile        := FileCreate (StFile);
    if iFile <= 0 Then
      raise Exception.CreateFmt ('Can''t save file %s', [StFile]);
    Stream        := THandleStream.Create (iFile);
    Try
        SaveToStream(Stream);
  Finally
        Stream.Free;
     FileClose (iFile);
    End;
  Result    := TRUE;
End;
Procedure TDuckQuery.SaveToStream (Stream: TStream);
Var
    i:                    Integer;
  TablePtr:        PRDQTable;
    LinkPtr:            PRDQLink;
  FieldPtr:        PRDQField;
  CriteriasPtr:    PRDQCriterias;
  GroupPtr:        PRDQGroup;
  SortPtr:            PRDQSort;
    Procedure    WriteString (St: String);
    Var
        wSize:    Word;
    Begin
        wSize    := Length (St);
      Stream.WriteBuffer (wSize, Sizeof (Word));
      if wSize > 0 Then
          Stream.WriteBuffer (St[1], wSize);
  End;
  Procedure    WriteCount (iCount: Integer);
  Begin
      Stream.WriteBuffer (iCount, Sizeof (iCount));
  End;
Begin
    Stream.WriteBuffer (DQ_PTHIS_VERSION, 4);
  Stream.WriteBuffer (FDuplicate, Sizeof (FDuplicate));

  WriteCount (FTables.Count);
    For i := 0 To FTables.Count - 1 Do
    Begin
      TablePtr    := FTables[i];
     WriteString (TablePtr.DataBase);
     WriteString (TablePtr.Table);
     WriteString (TablePtr.Alias);
    End;

  WriteCount (FTableLink.Count);
  For i := 0 To FTableLink.Count - 1 Do
    Begin
      LinkPtr    := FTableLink[i];
     Stream.WriteBuffer (LinkPtr.TableLinkType, Sizeof (TDQLinkType));
        WriteString (LinkPtr.MAlias);
        WriteString (LinkPtr.MField);
        WriteString (LinkPtr.DAlias);
     WriteString (LinkPtr.DField);
    End;

  WriteCount (FSelectFields.Count);
  For i := 0 To FSelectFields.Count - 1 Do
    Begin
      FieldPtr    := FSelectFields[i];
        WriteString (FieldPtr.Data);
        WriteString (FieldPtr.ColumnName);
    End;

  WriteCount (FCriterias.Count);
  For i := 0 To FCriterias.Count - 1 Do
    Begin
      CriteriasPtr    := FCriterias[i];
        WriteString (CriteriasPtr.Field);
     Stream.WriteBuffer (CriteriasPtr.CriteriaType, Sizeof (TDQCriteriaType));
     WriteString (CriteriasPtr.Value1);
     WriteString (CriteriasPtr.Value2);
     Stream.WriteBuffer (CriteriasPtr.AddType, Sizeof (TDQCriteriaAdd));
    End;

  WriteCount (FGroups.Count);
  For i := 0 To FGroups.Count - 1 Do
    Begin
      GroupPtr    := FGroups[i];
        WriteString (GroupPtr.Field);
    End;

  WriteCount (FSorts.Count);
  For i := 0 To FSorts.Count - 1 Do
    Begin
      SortPtr    := FSorts[i];
     Stream.WriteBuffer (SortPtr.SortType, Sizeof (TDQSortType));
        WriteString (SortPtr.Field);
    End;
End;
Function TDuckQuery.OpenFile (StFile: String): Boolean;
Var
  iFile:    Integer;
    Stream:    THandleStream;
Begin
  iFile    := FileOpen (StFile, fmOpenRead or fmShareDenyNone);
    if iFile <= 0 Then
      raise Exception.CreateFmt ('Can''t open file %s.', [StFile]);
  Clear;
  Stream        := THandleStream.Create (iFile);
  Try
      Result    := LoadFromStream (Stream);
  Finally
        Stream.Free;
     FileClose (iFile);
     if Result Then
         DoSQL;
    End;
End;
Function TDuckQuery.LoadFromStream (Stream: TStream): Boolean;
Var
    StVersion:    String;
  iThis:        Integer;
  i:                Integer;
  St:            String;
  StFile:        TFileName;

  TablePtr:        RDQTable;
    LinkPtr:            RDQLink;
  FieldPtr:        RDQField;
  CriteriasPtr:    RDQCriterias;
  GroupPtr:        RDQGroup;
  SortPtr:            RDQSort;
  iCount:            Integer;

  Function    ReadString: String;
    Var
        wSize:    Word;
      lpCh:        PChar;
    Begin
        Stream.ReadBuffer (wSize, Sizeof (Word));
      SetLength (Result, wSize);
      if wSize > 0 Then
          Stream.ReadBuffer (Result[1], wSize);
    End;
  Function    ReadCount: Integer;
  Begin
      Result    := 0;
     Stream.ReadBuffer (Result, Sizeof (Integer));
  End;
Begin
    Result    := FALSE;
  SetLength (StVersion, 4);
    Stream.ReadBuffer (StVersion[1], 4);
    FVersion        := DQGetVersion (StVersion);
  if FVersion = 0 Then
      raise Exception.Create ('This is not a valid Duck Query file.');
    iThis            := DQGetVersion (DQ_PTHIS_VERSION);
    if FVersion > iThis Then
     raise Exception.Create ('Incorrect Version');

  Stream.ReadBuffer (FDuplicate, Sizeof (FDuplicate));

  iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
     TablePtr.DataBase    := ReadString;
     TablePtr.Table        := ReadString;
     TablePtr.Alias        := ReadString;
     FTables.Add (@TablePtr);
    End;

  iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
     Stream.ReadBuffer (LinkPtr.TableLinkType, Sizeof (TDQLinkType));
        LinkPtr.MAlias        := ReadString;
        LinkPtr.MField        := ReadString;
        LinkPtr.DAlias        := ReadString;
     LinkPtr.DField        := ReadString;
     FTableLink.Add (@LinkPtr);
    End;

    iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
        FieldPtr.Data            := ReadString;
        FieldPtr.ColumnName    := ReadString;
     FSelectFields.Add (@FieldPtr);
    End;

  iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
        CriteriasPtr.Field    := ReadString;
     Stream.ReadBuffer (CriteriasPtr.CriteriaType, Sizeof (TDQCriteriaType));
     CriteriasPtr.Value1    := ReadString;
     CriteriasPtr.Value2    := ReadString;
     Stream.ReadBuffer (CriteriasPtr.AddType, Sizeof (TDQCriteriaAdd));
     FCriterias.Add (@CriteriasPtr);
    End;

  iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
        GroupPtr.Field    := ReadString;
     FGroups.Add (@GroupPtr);
    End;

  iCount    := ReadCount;
    For i := 0 To iCount - 1 Do
    Begin
     Stream.ReadBuffer (SortPtr.SortType, Sizeof (TDQSortType));
        SortPtr.Field    := ReadString;
     FSorts.Add (@SortPtr);
    End;
  Result    := TRUE;
End;
Function TDuckQuery.SaveTextFile (StFile: String): Boolean;
Var
  Items:    TStrings;
Begin
    Result    := FALSE;
  Items        := TStrings.Create;
    Try
      GetSQL (Items);
     Items.SaveToFile (StFile);
  Finally
      Items.Free;
    End;
  Result    := TRUE;
End;
Procedure TDuckQuery.Editor (Index: Integer);
Begin
    FormQuery        := TFormQuery.Create (nil);
  FormQuery.TNotebook.PageIndex    := Index;
  FormQuery.DuckQuery.Assign (Self);
  FormQuery.ShowModal;
  Try
      if FormQuery.ModalResult = mrOK Then
      Begin
        Self.Assign (FormQuery.DuckQuery);
        if Active Then
            Active    := FALSE;
            DoSQL;
     End;
  Finally
      FormQuery.Free;
  End;
End;
Function TDuckQuery.OpenFileDlg: Boolean;
Var
    OpenDlg:        TOpenDialog;
Begin
    Result    := FALSE;
    OpenDlg                    := TOpenDialog.Create (nil);
    OpenDlg.DefaultExt    := 'dqf';
    OpenDlg.Filter            := 'Duck Query (*.dqf)|*.dqf|All File (*.*)|*.*';
    OpenDlg.FileName        := '';
  if not OpenDlg.Execute Then
    Begin
        OpenDlg.Free;
     Exit;
  End;
  Try
      Result    := OpenFile (OpenDlg.FileName);
  Finally
      OpenDlg.Free;
  End;
End;
Function TDuckQuery.SaveFileDlg: Boolean;
Var
    SaveDlg:        TSaveDialog;
Begin
    Result    := FALSE;
    SaveDlg    := TSaveDialog.Create (nil);
    SaveDlg.DefaultExt    := 'dqf';
    SaveDlg.Filter            := 'Duck Query (*.dqf)|*.dqf|All File (*.*)|*.*';
    SaveDlg.FileName        := '';
    if not SaveDlg.Execute Then
  Begin
        SaveDlg.Free;
     Exit;
  End;
  Try
        Result    := SaveFile (SaveDlg.FileName);
  Finally
      SaveDlg.Free;
    End;
End;
Function TDuckQuery.SaveTxtFileDlg: Boolean;
Var
    SaveDlg:        TSaveDialog;
Begin
    Result    := FALSE;
    SaveDlg    := TSaveDialog.Create (nil);
    SaveDlg.DefaultExt    := 'txt';
  SaveDlg.Filter            := 'Text Document (*.txt)|*.txt|All File (*.*)|*.*';
    SaveDlg.FileName        := '';
    if not SaveDlg.Execute Then
  Begin
        SaveDlg.Free;
     Exit;
  End;
  Try
        Result    := SaveTextFile (SaveDlg.FileName);
  Finally
      SaveDlg.Free;
    End;
End;
Procedure TDuckQuery.ViewSQL;
Begin
    FormDQViewText    := TFormDQViewText.Create (nil);
    GetSQL (FormDQViewText.Memo.Lines);
    FormDQViewText.ShowModal;
    FormDQViewText.Free;
End;
End.